using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;
using CreditoAutorizado.CamadaAcessoDadosNH;
using CreditoAutorizado.Controlador;
using CreditoAutorizado.Dados.Entidades;
using CreditoAutorizado.Util;

namespace CreditoAutorizado.Servico
{
    public class Fachada
    {

        #region Atributos

        private static Fachada _unique = null;
        private ControladorUsuarios _controladorUsuarios;
        private ControladorCliente _controladorCliente;
        private ControladorComentario _controladorComentario;
        private ControladorDebito _controladorDebito;

        #endregion

        #region GetInstancia

        public static Fachada GetInstancia()
        {
            if (_unique == null)
            {
                _unique = new Fachada();
            }
            return _unique;
        }

        #endregion

        #region Construtor

        public Fachada()
        {
            Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");
         
            _controladorUsuarios = new ControladorUsuarios();
            _controladorCliente = new ControladorCliente();
            _controladorComentario = new ControladorComentario();
            _controladorDebito = new ControladorDebito();
        }

        #endregion

        #region Usuario

        public Usuario Inserir(Usuario usuario)
        {
            Usuario usuariotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                usuariotmp = _controladorUsuarios.Inserir(usuario);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                usuariotmp = null;
                throw new SCException(ex.Message);
            }
            return usuariotmp;
        }

        public Usuario Atualizar(Usuario usuario)
        {
            Usuario usuariotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                usuariotmp = _controladorUsuarios.Atualizar(usuario);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                usuariotmp = null;
                throw new SCException(ex.Message);
            }
            return usuariotmp;
        }


        public void ExluirUsuario(int id)
        {

            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                _controladorUsuarios.Excluir(id);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }

        }

        public IList<Usuario> ObterTodosUsuarios()
        {
            return _controladorUsuarios.ObterTodos();
        }

        public Usuario ObterUsuarioPorId(int id)
        {
            return _controladorUsuarios.ObterPorId(id);
        }

        public Usuario ObterUsuarioPorEmailESenha(string email, string senha)
        {
            return _controladorUsuarios.ObterPorEmailESenha(email, senha);
        }

        #endregion

        #region Cliente

        public Cliente Inserir(Cliente cliente)
        {
            Cliente clientetmp;
            GerenciadorBD.Instance.IniciarTransacao();

            try
            {
                clientetmp = _controladorCliente.Inserir(cliente);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }

            return clientetmp;
        }

        public Cliente Atualizar(Cliente cliente)
        {
            Cliente clientetmp;
            GerenciadorBD.Instance.IniciarTransacao();

            try
            {
                clientetmp = _controladorCliente.Atualizar(cliente);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }

            return clientetmp;
        }

        public void ExcluirCliente(int id)
        {
           
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                _controladorCliente.Excluir(id);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }
            
        }

        public IList<Cliente> ObterTodosClientes()
        {
            return _controladorCliente.ObterTodos();
        }

        public Cliente ObterClientePorId(int id)
        {
            return _controladorCliente.ObterPorId(id);
        }

        public IList<Cliente> ObterClientePorDados(string dados)
        {
            return _controladorCliente.ObterClientePorDados(dados);
        }

        public IList<Cliente> ObterClientePorDadosEUsuario(string dados, Usuario usuario)
        {
            return _controladorCliente.ObterClientePorDadosEUsuario(dados, usuario);
        }

        #endregion

        #region Comentario

        public Comentario Inserir(Comentario comentario)
        {
            Comentario comentariotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                comentariotmp = _controladorComentario.Inserir(comentario);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                comentariotmp = null;
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }

            return comentariotmp;
        }

        public Comentario Atualizar(Comentario comentario)
        {
            Comentario comentariotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                comentariotmp = _controladorComentario.Atualizar(comentario);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                comentariotmp = null;
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }

            return comentariotmp;
        }

        public void ExcluirComentario(int id)
        {
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                _controladorComentario.Excluir(id);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }
        }

        public IList<Comentario> ObterTodosComentarios()
        {
            return _controladorComentario.ObterTodos();
        }

        public Comentario ObterComentarioPorId(int id)
        {
            return _controladorComentario.ObterPorId(id);
        }

        #endregion

        #region Debito

        public Debito Inserir(Debito debito)
        {
            Debito debitotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                debitotmp = _controladorDebito.Inserir(debito);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                debitotmp = null;
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }
            return debitotmp;
        }

        public Debito Atualizar(Debito debito)
        {
            Debito debitotmp;
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                debitotmp = _controladorDebito.Atualizar(debito);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                debitotmp = null;
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }
            return debitotmp;
        }

        public void ExcluirDebito(int id)
        {
            GerenciadorBD.Instance.IniciarTransacao();
            try
            {
                _controladorDebito.Excluir(id);
                GerenciadorBD.Instance.ConfirmarTransacao();
            }
            catch (Exception ex)
            {
                GerenciadorBD.Instance.CancelarTransacao();
                throw new SCException(ex.Message);
            }
        }

        public IList<Debito> ObterTodosDebitos()
        {
            return _controladorDebito.ObterTodos();
        }

        public Debito ObterDebitoPorId(int id)
        {
            return _controladorDebito.ObterPorId(id);
        }

        public IList<Debito> ObterTodosDebitosPorCliente(Cliente cliente)
        {
            return _controladorDebito.ObterTodosPorCliente(cliente);
        }

        public IList<Debito> ObterTodosDebitosPorClienteEUsuario(Cliente cliente, Usuario usuario)
        {
            return _controladorDebito.ObterTodosPorClienteEUsuario(cliente, usuario);
        }

        #endregion

    }
}